home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1996 February: Tool Chest / Apple Developer CD Series Tool Chest February 1996 (Apple Computer)(1996).iso / Tool Chest / Testing & Debugging / General tools / Audit app & dcmd / Src / AuditEntryFormat.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-09-17  |  6.8 KB  |  264 lines  |  [TEXT/KAHL]
  1. /*                                AuditEntryFormat.c                                */
  2. /*
  3.  * AuditEntryFormat.c
  4.  * Copyright © 1992-93 Apple Computer Inc. All Rights Reserved.
  5.  * Programmed by Martin Minow,
  6.  *    Internet:    minow@apple.com
  7.  *    AppleLink:    MINOW
  8.  * Version of January 14, 1993
  9.  *
  10.  * Edit History
  11.  *    93.01.09 MM        First public release
  12.  *    93.07.09 MM        Reformatted for 80-column page. No substantive changes.
  13.  *    93.08.25 MM        Added "Roman Script" bit vector for character visibility.
  14.  * Format an AuditEntryRecord. Note: there is no size checking, which means that
  15.  * if you somehow manage to create an extra-long record, you'll get garbage. The
  16.  * functions won't corrupt memory, however.
  17.  */
  18. #include "Audit.h"
  19. #include <Memory.h>
  20. #include <OSUtils.h>
  21.  
  22. /*
  23.  * result may not have side-effects.
  24.  */
  25. #define AppendChar(result, c) (result[++result[0]] = (c))
  26. static void        AppendUnsigned(StringPtr, unsigned long);
  27. static void        AppendSigned(StringPtr, signed long);
  28. static void        AppendUnsignedLeadingZeros(StringPtr, unsigned long, short, short);
  29. static void        AppendHexLeadingZeros(StringPtr, unsigned long, short);
  30. static void        AppendPascalString(StringPtr, const StringPtr);
  31. static void        AppendOSType(StringPtr, OSType);
  32.  
  33. enum {
  34.     NUL            = 0,
  35.     kOpenQuote    = 0xD2,
  36.     kCloseQuote    = 0xD3
  37. };
  38.  
  39. #define AUDIT    (*auditPtr)
  40. #define ENTRY    (*entryPtr)
  41.  
  42. /*
  43.  * FormatAuditEntryData() converts an audit record entry into readable text,
  44.  * storing the result in the Pascal string argument.
  45.  */
  46. void
  47. FormatAuditEntryData(
  48.         register AuditEntryPtr    entryPtr,
  49.         StringPtr                result
  50.     )
  51. {
  52.         unsigned long                datum;
  53.         unsigned long                format;
  54.         unsigned short                thisFormat;
  55.         register unsigned long        *dataPtr;
  56.         unsigned long                *dataEnd;
  57.         
  58.         result[0] = 0;
  59.         if (ENTRY.lostData != 0) {
  60.             AppendUnsigned(result, ENTRY.lostData);
  61.             AppendPascalString(result, "\p lost, ");
  62.         }
  63.         AppendOSType(result, ENTRY.idCode);
  64.         AppendPascalString(result, "\p: ");
  65.         format = ENTRY.format;
  66.         dataPtr = ENTRY.data;
  67.         dataEnd = &ENTRY.data[8];
  68.         while (dataPtr < dataEnd) {
  69.             thisFormat = (format & kAuditFormatMask);
  70.             format >>= kAuditFormatShift;
  71.             if (thisFormat == kAuditFormatEnd)
  72.                 break;
  73.             else if (thisFormat == kAuditFormatString) {
  74.                 if (dataPtr > &ENTRY.data[0])
  75.                     AppendChar(result, ' ');
  76.                 AppendChar(result, kOpenQuote);            /* Open double quote    */
  77.                 AppendPascalString(result, (StringPtr) dataPtr);
  78.                 AppendChar(result, kCloseQuote);
  79.                 break;                                    /* Exit loop            */
  80.             }
  81.             else if (thisFormat == kAuditFormatLocation) {
  82.                 if (dataPtr > &ENTRY.data[0])
  83.                     AppendChar(result, ' ');
  84.                 datum = *dataPtr++;                        /* Offset                */
  85.                 if (datum == 0 && dataPtr < dataEnd)
  86.                     AppendHexLeadingZeros(result, *dataPtr, 8);
  87.                 else {
  88.                     if (dataPtr < dataEnd)
  89.                         AppendPascalString(result, (StringPtr) dataPtr);
  90.                     AppendPascalString(result, "\p + 0x");
  91.                     AppendHexLeadingZeros(result, datum, 4);
  92.                 }
  93.                 break;                                    /* Exit loop            */
  94.             }
  95.             else {
  96.                 if (dataPtr > &ENTRY.data[0])
  97.                     AppendPascalString(result, "\p, ");
  98.                 datum = *dataPtr++;
  99.                 switch (thisFormat) {
  100.                 case kAuditFormatSigned:
  101.                     AppendSigned(result, (signed long) datum);
  102.                     break;
  103.                 case kAuditFormatUnsigned:
  104.                     AppendUnsigned(result, datum);
  105.                     break;
  106.                 case kAuditFormatHex:
  107.                     AppendHexLeadingZeros(result, datum, 8);
  108.                     AppendPascalString(result, "\p=");
  109.                     AppendOSType(result, datum);
  110.                     break;
  111.                 case kAuditFormatAddress:
  112.                 default:                        /* Unknown        */
  113.                     AppendHexLeadingZeros(result, datum, 8);
  114.                     break;
  115.                 }
  116.             }
  117.         }
  118. #undef DATA
  119. }
  120.  
  121. /*
  122.  * FormatAuditEntryTimestamp() converts an audit record entry's timestamp into
  123.  * readable text, storing the result in the Pascal string argument.
  124.  */
  125. void
  126. FormatAuditEntryTimestamp(
  127.         register AuditPtr        auditPtr,
  128.         register AuditEntryPtr    entryPtr,
  129.         StringPtr                result
  130.     )
  131. {
  132.         unsigned long            elapsedTicks;
  133.         unsigned long            timeNow;
  134.         DateTimeRec                dateTimeRec;
  135.         
  136.         result[0] = 0;
  137.         elapsedTicks = ENTRY.tickCount - AUDIT.ticksAtStart;
  138.         timeNow = AUDIT.timeAtStart + (elapsedTicks / 60L);
  139.         Secs2Date(timeNow, &dateTimeRec);
  140.         AppendUnsignedLeadingZeros(result, dateTimeRec.year,    4, '.');
  141.         AppendUnsignedLeadingZeros(result, dateTimeRec.month,    2, '.');
  142.         AppendUnsignedLeadingZeros(result, dateTimeRec.day,        2, ' ');
  143.         AppendUnsignedLeadingZeros(result, dateTimeRec.hour,    2, ':');
  144.         AppendUnsignedLeadingZeros(result, dateTimeRec.minute,    2, ':');
  145.         AppendUnsignedLeadingZeros(result, dateTimeRec.second,    2, '.');
  146.         elapsedTicks = ((elapsedTicks % 60L) * 1000L) / 60L;    /* Msec    */
  147.         AppendUnsignedLeadingZeros(result, elapsedTicks,        3, NUL);
  148. }
  149.  
  150. /*
  151.  * Output an n-digit decimal value with leading zeros.
  152.  */
  153. static void
  154. AppendUnsignedLeadingZeros(
  155.         StringPtr            result,
  156.         unsigned long        value,
  157.         short                digits,
  158.         short                terminator
  159.         
  160.     )
  161. {
  162.         if (--digits > 0)
  163.             AppendUnsignedLeadingZeros(result, value / 10, digits, NUL);
  164.         AppendChar(result, (value % 10) + '0');
  165.         if (terminator != NUL)
  166.             AppendChar(result, terminator);
  167. }
  168.  
  169. /*
  170.  * Output a signed decimal longword.
  171.  */
  172. static void
  173. AppendSigned(
  174.         StringPtr            result,
  175.         signed long            value
  176.     )
  177. {
  178.         if (value < 0) {
  179.             AppendChar(result, '-');
  180.             value = (-value);
  181.         }
  182.         AppendUnsigned(result, (unsigned long) value);
  183. }
  184.  
  185. /*
  186.  * Output an unsigned decimal longword.
  187.  */
  188. static void
  189. AppendUnsigned(
  190.         StringPtr            result,
  191.         unsigned long        value
  192.     )
  193. {
  194.         if (value >= 10)
  195.             AppendUnsigned(result, value / 10);
  196.         AppendChar(result, (value % 10) + '0');
  197. }
  198.  
  199. /*
  200.  * Output a string of hex digits with leading zeros.
  201.  */
  202. static void
  203. AppendHexLeadingZeros(
  204.         StringPtr            result,
  205.         unsigned long        value,
  206.         short                digits
  207.     )
  208. {
  209.         if (--digits > 0)
  210.             AppendHexLeadingZeros(result, value >> 4, digits);
  211.         value &= 0x0F;
  212.         AppendChar(result,
  213.                 (value < 10)
  214.                 ? value + '0'
  215.                 : (value + ('A' - 10))
  216.             );
  217. }
  218.  
  219. /*
  220.  * Output a 4-byte character string. Unknown bytes are replaced by '•'. 
  221.  * Note: this presumes that we are using the "Roman" script.
  222.  */
  223. static void
  224. AppendOSType(
  225.         StringPtr                result,
  226.         OSType                    datum
  227.     )
  228. {
  229.         unsigned char            value[sizeof (OSType)];
  230.         register short            i;
  231.         register unsigned short    c;
  232.         static const unsigned long bitVector[256 / 32] = {
  233.             0x00000000,                /* 00-1F   0 - 31                */
  234.             0xFFFFFFFF,                /* 20-3F  32 - 63    ' ' '?'        */
  235.             0xFFFFFFFF,                /* 34-5F  64 - 95    '@' '_'        */
  236.             0x7FFFFFFF,                /* 60-7F  96 - 127    '`' Del        */
  237.             0xFFFFFFFF,                /* 80-9F 128 - 159                */
  238.             0xFFFFFFFF,                /* A0-BF 160 - 191                */
  239.             0x1FFFFFFF,                /* C0-BF 192 - 223                */
  240.             0x00010000                /* E0-FF 224 - 255                */
  241.         };
  242.         BlockMove(&datum, value, sizeof (OSType));
  243.         AppendChar(result, '\'');
  244.         for (i = 0; i < sizeof (OSType); i++) {
  245.             c = value[i];
  246.             if ((bitVector[c >> 5] & (1LU << (c & 31))) == 0)
  247.                 c = 0xA5;                /* Big dot    */
  248.             AppendChar(result, c);
  249.         }
  250.         AppendChar(result, '\'');
  251. }
  252.  
  253. static void
  254. AppendPascalString(
  255.         StringPtr                result,
  256.         const StringPtr            datum
  257.     )
  258. {
  259.         register short            i;
  260.         
  261.         for (i = 1; i <= datum[0]; i++)
  262.             AppendChar(result, datum[i]);
  263. }
  264.